package com.dreamoo.common.exception;

import com.dreamoo.common.result.ResultCode;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.util.Collection;
import java.util.Map;

/**
 * 断言工具类
 * 用于参数校验，如果不满足条件则抛出异常
 * 
 * @author dreamoo
 */
public class Assert {

    /**
     * 断言对象不为空，如果为空，则抛出业务异常
     *
     * @param object  对象
     * @param message 异常消息
     */
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言对象不为空，如果为空，则抛出业务异常
     *
     * @param object     对象
     * @param resultCode 错误码
     */
    public static void notNull(Object object, ResultCode resultCode) {
        if (object == null) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言字符串不为空，如果为空，则抛出业务异常
     *
     * @param text    字符串
     * @param message 异常消息
     */
    public static void notEmpty(String text, String message) {
        if (!StringUtils.hasLength(text)) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言字符串不为空，如果为空，则抛出业务异常
     *
     * @param text       字符串
     * @param resultCode 错误码
     */
    public static void notEmpty(String text, ResultCode resultCode) {
        if (!StringUtils.hasLength(text)) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言集合不为空，如果为空，则抛出业务异常
     *
     * @param collection 集合
     * @param message    异常消息
     */
    public static void notEmpty(Collection<?> collection, String message) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言集合不为空，如果为空，则抛出业务异常
     *
     * @param collection 集合
     * @param resultCode 错误码
     */
    public static void notEmpty(Collection<?> collection, ResultCode resultCode) {
        if (CollectionUtils.isEmpty(collection)) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言Map不为空，如果为空，则抛出业务异常
     *
     * @param map     Map
     * @param message 异常消息
     */
    public static void notEmpty(Map<?, ?> map, String message) {
        if (CollectionUtils.isEmpty(map)) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言Map不为空，如果为空，则抛出业务异常
     *
     * @param map        Map
     * @param resultCode 错误码
     */
    public static void notEmpty(Map<?, ?> map, ResultCode resultCode) {
        if (CollectionUtils.isEmpty(map)) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言布尔表达式为真，如果为假，则抛出业务异常
     *
     * @param expression 布尔表达式
     * @param message    异常消息
     */
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言布尔表达式为真，如果为假，则抛出业务异常
     *
     * @param expression 布尔表达式
     * @param resultCode 错误码
     */
    public static void isTrue(boolean expression, ResultCode resultCode) {
        if (!expression) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言对象为指定类型的实例，如果不是，则抛出业务异常
     *
     * @param obj     对象
     * @param type    类型
     * @param message 异常消息
     */
    public static void isInstanceOf(Object obj, Class<?> type, String message) {
        notNull(obj, message);
        if (!type.isInstance(obj)) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言对象为指定类型的实例，如果不是，则抛出业务异常
     *
     * @param obj        对象
     * @param type       类型
     * @param resultCode 错误码
     */
    public static void isInstanceOf(Object obj, Class<?> type, ResultCode resultCode) {
        notNull(obj, resultCode);
        if (!type.isInstance(obj)) {
            throw new BusinessException(resultCode);
        }
    }

    /**
     * 断言两个对象相等，如果不相等，则抛出业务异常
     *
     * @param obj1    对象1
     * @param obj2    对象2
     * @param message 异常消息
     */
    public static void equals(Object obj1, Object obj2, String message) {
        if (!ObjectUtils.nullSafeEquals(obj1, obj2)) {
            throw new BusinessException(message);
        }
    }

    /**
     * 断言两个对象相等，如果不相等，则抛出业务异常
     *
     * @param obj1       对象1
     * @param obj2       对象2
     * @param resultCode 错误码
     */
    public static void equals(Object obj1, Object obj2, ResultCode resultCode) {
        if (!ObjectUtils.nullSafeEquals(obj1, obj2)) {
            throw new BusinessException(resultCode);
        }
    }
} 